humane syntax???:
----------------

break down member (x, list) -> ([#found | #not-found], value) {
    finish when list is empty { ^ #not-found, ɸ }
    finish when x in list     { ^ #found, list }
    decompose list' <- rest (list) {
	    ^ again (x, list')
	}
}

break down append (x, list) -> value {
    finish when list is empty { ^ x }
    decompose «item» <- first (list), «list'» <- rest (list) {
        ^ prepend «item» onto again (x, «list'»))
    }
}

inhumane syntax:
----------------

(defun my_member (x lis)
  (cond ((null lis) (values nil nil))
        ((eq x (car lis)) (values t lis))
	(t (my_member x (cdr lis)))))


(defun my_append (lis x)
  (cond ((null lis) x)
        (t (cons (car lis) (my_append (cdr lis) x)))))

less-inhumane syntax involving async ports:
-------------------------------------------

break down member (x, list) output ports: { success: [#found | #not-found], value: object } {
    finish when list is empty { send success: #not-found, send value: ɸ }
    finish when x in list     { send success: #found, send value: list }
    decompose list' <- rest (list) {
	    ^again (x, list')
	}
}

break down append (x, list) output port: { value: object } {
    finish when list is empty { send value: x }
    decompose «item» <- first (list), «list'» <- rest (list) {
        send value: prepend «item» onto ^again (x, «list'»))
    }
}

# instead of:
if bla:
    do_bla()
   if blabla:
       do_blabla()
   else:
       other()
else:
    other()

# do
if bla {
do_bla()
if blabla() {
do_blabla()
} 
else {
other()
}
else {
other()
}

if bla do_bla() else other()

#define do_bla somewhere somehow in a way that keeps the same scope without param/stack rules

(Bob, Bob's age)
(Bob's age, 23yrs)

# Tasks are enqueued jobs to specific queues. They emit events like started, success, failure, cancelled as well as custom intermediate events.
# Tasks cannot consume events. Task invoker can cancel those tasks.
# Tasks are triggerred by specific events indicated by their corresponding "when" clause.
# Process is a stateful workflow which orchestrates tasks based on events.

process pizza() do
    x = @customer.select_pizza when $start
    y = @customer.order_pizza(kind: x.kind) when x
    z = @chef.make_pizza(order: y.order) when y
    
    p = y.order.line_items.map do |item| # array processing
        subprocess procure(item: item) #invoke a subprocess
    end when z
    q = @clerk.pack when p.all?
    
    w = @delivery_boy.deliver_pizza(to: y.address) when z
    u = @customer.pay_for_pizza when w
    v = @customer.eat_pizza when u
    success $hunger_satisfied when v

    r = @customer.ask_for_pizza when (y or r[-1] + 60.minutes) and w.pending?
    s = @clerk.calm_the_customer when r
end

The Cabin is a room.  "The front of the small cabin is entirely occupied with navigational instruments, a radar display, and radios for calling back to shore. Along each side runs a bench with faded blue vinyl cushions, which can be lifted to reveal the storage space underneath. A glass case against the wall contains several fishing rods.

Scratched windows offer a view of the surrounding bay, and there is a door south to the deck. A sign taped to one wall announces the menu of tours offered by the Yakutat Charter Boat Company."

The Cabin contains a glass case. In the glass case is a collection of fishing rods.

The case is closed, transparent, and openable.

The bench is in the cabin. On the bench are some blue vinyl cushions.

The bench is enterable.

The Beach is a room. "A beautiful beach where the sunset can be seen. Some seagulls are flying overhead."
The Beach is south of the Cabin.

# here's a sample program in my (object oriented) language
fn add(a, b) = a + b
add(1, 2)

-- preloaded facts
lookup(#Number, :+, {args: [#Number, #Number], ret: #Number}).

-- program
add(?a, ?b, ?ret) :- lookup(?a, :+, {args: [?a, ?b], ret: ?ret}).
?- add(1, 2, ?_).

    USER_PROFILE = "/user-profile"
>     SEARCH = "/search"
>     NOTIFICATIONS = "/notifications"
>     SETTINGS = "/settings"
>     HELP = "/help"
>     CHAT = "/chat"
>     DOCS = "/docs"
>     PROJECTS = "/projects"
>     WORKSPACES = "/workspaces"
> 
> 
> AppRoute("update my name")
> # AppRoute.USER_PROFILE